Системное программирование в UNIX/Linux

План лекции

1. Стандарты UNIX

1.1. История UNIX

1.2. Стандарты

POSIX (Portable Operating System Interface) — набор стандартов IEEE, обеспечивающих совместимость между UNIX-системами.

• POSIX.1 — базовые интерфейсы (файлы, процессы, сигналы)
• POSIX.1b — реальное время (таймеры, разделяемая память)
• POSIX.1c — потоки (pthreads)

Single UNIX Specification (SUS) — расширенный стандарт The Open Group. Соответствие SUS позволяет называть ОС «UNIX».

LSB (Linux Standard Base) — стандарт двоичной совместимости дистрибутивов Linux.

1.3. Пользователи и группы

Файл /etc/passwd — информация о пользователях:

username:x:UID:GID:GECOS:home_dir:shell
jsmith:x:1000:1000:John Smith:/home/jsmith:/bin/bash

Файл /etc/group — информация о группах:

groupname:password:GID:members
developers:x:1010:jsmith,alewis

1.4. Реальные и эффективные идентификаторы

Каждый процесс имеет несколько наборов UID/GID:

#include <unistd.h>
#include <stdio.h>

printf("Real UID: %d\n", getuid());
printf("Effective UID: %d\n", geteuid());
printf("Real GID: %d\n", getgid());
printf("Effective GID: %d\n", getegid());

2. Системные вызовы и библиотечные функции

2.1. Различие

Системный вызов (syscall) — запрос программы к ядру ОС на выполнение привилегированной операции.

Библиотечная функция — функция стандартной библиотеки (libc), которая может:

• Вызывать один или несколько syscalls (например, printf → write)
• Не использовать syscalls вообще (например, strlen, memcpy)

2.2. Обработка ошибок

Все системные вызовы и многие библиотечные функции возвращают признак ошибки:

#include <errno.h>
#include <stdio.h>
#include <string.h>

int fd = open("missing.txt", O_RDONLY);

if (fd == -1) {
    perror("open");
    printf("Код ошибки: %d (%s)\n", errno, strerror(errno));
}

Стандартные переменные:

• errno — код последней ошибки (определяется в <errno.h>)
• perror() — выводит сообщение об ошибке в stderr
• strerror() — возвращает строковое описание ошибки

2.3. Компиляция программы на C

Этапы компиляции GCC:

gcc -E program.c -o program.i
gcc -S program.i -o program.s
gcc -c program.s -o program.o
gcc program.o -o program

Или одной командой:

gcc -Wall -Wextra -o program program.c

3. Форматы исполняемых файлов

3.1. Формат ELF

ELF (Executable and Linkable Format) — стандартный формат исполняемых файлов в Linux и большинстве UNIX-систем.

Структура ELF-файла:

3.2. Инструменты анализа ELF

file /bin/ls

readelf -h /bin/ls

readelf -S /bin/ls

readelf -l /bin/ls

nm /bin/ls

objdump -d /bin/ls | head -50

4. Типы файлов UNIX

4.1. Классификация

ls -la /dev
crw-rw-rw- 1 root root 1, 3 Jan 1 00:00 /dev/null
brw-rw---- 1 root disk 8, 0 Jan 1 00:00 /dev/sda
lrwxrwxrwx 1 root root 4 Jan 1 00:00 /dev/cdrom -> sr0

4.2. Определение типа файла программно

#include <sys/stat.h>
#include <stdio.h>

struct stat st;

if (lstat("example", &st) == 0) {
    if (S_ISREG(st.st_mode))  printf("Обычный файл\n");
    if (S_ISDIR(st.st_mode))  printf("Каталог\n");
    if (S_ISLNK(st.st_mode))  printf("Символическая ссылка\n");
    if (S_ISCHR(st.st_mode))  printf("Символьное устройство\n");
    if (S_ISBLK(st.st_mode))  printf("Блочное устройство\n");
    if (S_ISFIFO(st.st_mode)) printf("FIFO\n");
    if (S_ISSOCK(st.st_mode)) printf("Сокет\n");
}

5. Управление правами доступа

5.1. Модель прав UNIX

Три категории пользователей:

• Owner (владелец) — создатель файла
• Group (группа) — группа-владелец
• Others (остальные) — все прочие

Три типа прав:

• r (read) — чтение (4)
• w (write) — запись (2)
• x (execute) — выполнение (1)

-rwxr-xr-- 1 jsmith developers 4096 Jan 15 10:30 script.sh
 ├─  ├───┤  ├───┤  ├───┤
 тип  owner group others
      rwx    r-x    r--
      7      5      4

5.2. Изменение прав

chmod 755 script.sh
chmod u+x script.sh
chmod g-w script.sh
chmod o=r script.sh
chmod -R 644 /var/www/

#include <sys/stat.h>

chmod("file.txt", 0644);

chown("file.txt", 1001, 1001);

umask — маска, вычитаемая из прав при создании файла:

umask 0022
# Файл: 0666 & ~0022 = 0644
# Каталог: 0777 & ~0022 = 0755

5.3. Специальные биты

Пример setuid:

ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 59976 /usr/bin/passwd

Пример sticky bit:

ls -ld /tmp
drwxrwxrwt 10 root root 4096 /tmp

5.4. ACL (Access Control Lists)

ACL расширяют стандартную модель прав, позволяя задавать права для конкретных пользователей и групп:

getfacl project.txt

setfacl -m u:alewis:rw project.txt

setfacl -m g:qa:r-x project.txt

setfacl -x u:alewis project.txt

setfacl -b project.txt

#include <sys/acl.h>

acl_t acl = acl_get_file("project.txt", ACL_TYPE_ACCESS);
acl_entry_t entry;
acl_create_entry(&acl, &entry);

acl_permset_t perms;
acl_get_permset(entry, &perms);
acl_add_perm(perms, ACL_READ | ACL_WRITE);

acl_set_file("project.txt", ACL_TYPE_ACCESS, acl);
acl_free(acl);

6. Атрибуты файлов и файловая система

6.1. Структура stat

#include <sys/stat.h>
#include <stdio.h>

struct stat st;

if (stat("file.txt", &st) == 0) {
    printf("Размер: %ld байт\n", st.st_size);
    printf("Блоки: %ld\n", st.st_blocks);
    printf("Размер блока IO: %ld\n", st.st_blksize);
    printf("Жёстких ссылок: %ld\n", st.st_nlink);
    printf("Inode: %ld\n", st.st_ino);
    printf("UID: %d\n", st.st_uid);
    printf("GID: %d\n", st.st_gid);
    printf("Последний доступ: %ld\n", st.st_atime);
    printf("Последнее изменение: %ld\n", st.st_mtime);
    printf("Последнее изменение метаданных: %ld\n", st.st_ctime);
}

6.2. Системные вызовы для работы с файлами

#include <fcntl.h>
#include <unistd.h>

int fd = open("data.bin", O_RDWR | O_CREAT, 0644);

ssize_t n = write(fd, "Hello", 5);

char buf[256];
n = read(fd, buf, sizeof(buf));

off_t pos = lseek(fd, 0, SEEK_SET);

int fd2 = dup(fd);

int fd3 = dup2(fd, STDERR_FILENO);

close(fd);

6.3. Дополнительные операции

#include <unistd.h>
#include <fcntl.h>

int result = access("file.txt", R_OK | W_OK);

truncate("file.txt", 1024);

int flags = fcntl(fd, F_GETFL);

fcntl(fd, F_SETFL, flags | O_NONBLOCK);

#include <sys/ioctl.h>

struct winsize ws;
ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
printf("Терминал: %d x %d\n", ws.ws_col, ws.ws_row);

6.4. Структура файловой системы

6.5. Файловые системы

mount -t ext4 /dev/sda1 /mnt
umount /mnt
df -hT
du -sh /home/*

7. Процессы в ОС UNIX

7.1. Типы процессов

7.2. Атрибуты процесса

#include <unistd.h>
#include <stdio.h>

printf("PID: %d\n", getpid());
printf("PPID: %d\n", getppid());
printf("UID: %d\n", getuid());
printf("GID: %d\n", getgid());
printf("Session ID: %d\n", getsid(0));
printf("Process Group: %d\n", getpgrp());

7.3. Файловая система /proc

/proc — виртуальная файловая система, предоставляющая информацию о процессах и ядре:

ls /proc/1234/

cat /proc/1234/status
cat /proc/1234/cmdline
cat /proc/1234/environ
cat /proc/1234/fd/
cat /proc/1234/maps

cat /proc/cpuinfo
cat /proc/meminfo
cat /proc/version

8. Создание и управление процессами

8.1. fork() — создание процесса

fork() создаёт точную копию текущего процесса (copy-on-write):

#include <unistd.h>
#include <stdio.h>

pid_t pid = fork();

if (pid == -1) {
    perror("fork");
} else if (pid == 0) {
    printf("Дочерний: PID=%d, PPID=%d\n", getpid(), getppid());
} else {
    printf("Родитель: PID=%d, дочерний=%d\n", getpid(), pid);
}

8.2. Copy-on-Write

8.3. exec() — замена образа процесса

#include <unistd.h>

execl("/bin/ls", "ls", "-l", "/tmp", NULL);

execlp("grep", "grep", "-r", "pattern", "/src", NULL);

char *args[] = {"wc", "-l", "file.txt", NULL};
execv("/usr/bin/wc", args);

execvp("wc", args);

char *envp[] = {"PATH=/bin", "HOME=/root", NULL};
execve("/bin/ls", args, envp);

8.4. wait() и waitpid()

#include <sys/wait.h>

pid_t pid = fork();

if (pid == 0) {
    execl("/bin/sleep", "sleep", "2", NULL);
    _exit(1);
}

int status;
waitpid(pid, &status, 0);

if (WIFEXITED(status)) {
    printf("Код завершения: %d\n", WEXITSTATUS(status));
}
if (WIFSIGNALED(status)) {
    printf("Убит сигналом: %d\n", WTERMSIG(status));
}

8.5. Зомби и сироты

Зомби (defunct) — завершённый процесс, чей родитель ещё не вызвал wait():

ps aux | grep Z

Сирота — процесс, чей родитель завершился. Усыновляется init (PID 1) или суб-reaper'ом:

if (fork() > 0) {
    _exit(0);
}

printf("Теперь PPID=%d (усыновлён)\n", getppid());

8.6. Приоритеты процессов

#include <sys/resource.h>
#include <unistd.h>

int prio = getpriority(PRIO_PROCESS, 0);

setpriority(PRIO_PROCESS, 0, prio + 5);

nice(5);

nice -n 10 ./heavy_task

renice -n -5 -p 1234

Диапазон nice-значений: от -20 (наивысший приоритет) до +19 (наинизший).

Только root может устанавливать отрицательные значения (повышать приоритет).

9. Сигналы и каналы

9.1. Стандартные сигналы

9.2. Отправка сигналов

kill -SIGTERM 1234

kill -9 1234

killall nginx

pkill -f "python script"

#include <signal.h>

kill(1234, SIGTERM);

raise(SIGSTOP);

killpg(getpgrp(), SIGINT);

9.3. Обработка сигналов

#include <signal.h>

void handler(int sig) {
    write(STDOUT_FILENO, "Сигнал получен\n", 15);
}

signal(SIGINT, handler);

signal(SIGPIPE, SIG_IGN);

#include <signal.h>

void handler(int sig, siginfo_t *info, void *context) {
    printf("Сигнал %d от процесса %d\n", sig, info->si_pid);
}

struct sigaction sa;
sa.sa_sigaction = handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO | SA_RESTART;

sigaction(SIGINT, &sa, NULL);

9.4. Блокировка сигналов

#include <signal.h>

sigset_t block_set, old_set;

sigemptyset(&block_set);
sigaddset(&block_set, SIGINT);
sigaddset(&block_set, SIGTERM);

sigprocmask(SIG_BLOCK, &block_set, &old_set);

sigprocmask(SIG_SETMASK, &old_set, NULL);

sigpending(&block_set);
if (sigismember(&block_set, SIGINT)) {
    printf("SIGINT ожидает доставки\n");
}

9.5. Неименованные каналы (pipes)

#include <unistd.h>
#include <stdio.h>

int pipefd[2];
pipe(pipefd);

pid_t pid = fork();

if (pid == 0) {
    close(pipefd[1]);

    char buf[256];
    ssize_t n = read(pipefd[0], buf, sizeof(buf));
    buf[n] = '\0';
    printf("Получено: %s\n", buf);

    close(pipefd[0]);
} else {
    close(pipefd[0]);

    write(pipefd[1], "Hello from parent", 17);
    close(pipefd[1]);

    wait(NULL);
}

9.6. Именованные каналы (FIFO)

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

mkfifo("/tmp/myfifo", 0666);

int fd = open("/tmp/myfifo", O_RDONLY);
char buf[256];
read(fd, buf, sizeof(buf));
printf("Получено: %s\n", buf);
close(fd);

int fd = open("/tmp/myfifo", O_WRONLY);
write(fd, "Hello FIFO", 10);
close(fd);

mkfifo /tmp/test_fifo
echo "message" > /tmp/test_fifo &
cat /tmp/test_fifo

10. Очереди сообщений, семафоры, разделяемая память

10.1. System V IPC

Общие команды управления:

ipcs -q
ipcs -s
ipcs -m

ipcrm -q 1234
ipcrm -s 5678
ipcrm -m 9012

Общий паттерн System V IPC:

1. Создать/открыть → *get (msgget, semget, shmget)
2. Управлять → *ctl (msgctl, semctl, shmctl)
3. Операции → *op/специфичные (msgsnd/msgrcv, semop, shmat/shmdt)

10.2. Очереди сообщений System V

#include <sys/msg.h>
#include <string.h>

struct message {
    long mtype;
    char mtext[256];
};

key_t key = ftok("/tmp", 'A');

int msqid = msgget(key, IPC_CREAT | 0666);

struct message msg;
msg.mtype = 1;
strncpy(msg.mtext, "Hello queue", sizeof(msg.mtext));
msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0);

msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0);
printf("Получено: %s (тип=%ld)\n", msg.mtext, msg.mtype);

msgctl(msqid, IPC_RMID, NULL);

10.3. Семафоры System V

#include <sys/sem.h>

key_t key = ftok("/tmp", 'B');
int semid = semget(key, 1, IPC_CREAT | 0666);

semctl(semid, 0, SETVAL, 1);

struct sembuf op_wait = {0, -1, 0};
struct sembuf op_signal = {0, 1, 0};

semop(semid, &op_wait, 1);

semop(semid, &op_signal, 1);

semctl(semid, 0, IPC_RMID);

10.4. Разделяемая память System V

#include <sys/shm.h>
#include <string.h>

key_t key = ftok("/tmp", 'C');
int shmid = shmget(key, 4096, IPC_CREAT | 0666);

char *data = (char *)shmat(shmid, NULL, 0);

strncpy(data, "Hello shared memory", 4096);

shmdt(data);

shmctl(shmid, IPC_RMID, NULL);

10.5. POSIX-альтернативы

#include <mqueue.h>

mqd_t mq = mq_open("/myqueue", O_CREAT | O_RDWR, 0666, NULL);

mq_send(mq, "Hello", 6, 1);

char buf[256];
unsigned int prio;
ssize_t n = mq_receive(mq, buf, sizeof(buf), &prio);

mq_close(mq);
mq_unlink("/myqueue");

#include <sys/mman.h>
#include <fcntl.h>

int fd = shm_open("/myshm", O_CREAT | O_RDWR, 0666);
ftruncate(fd, 4096);

char *data = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

munmap(data, 4096);
close(fd);
shm_unlink("/myshm");

10.6. Потоки POSIX (pthread)

#include <pthread.h>
#include <stdio.h>

void *worker(void *arg) {
    int id = *(int *)arg;
    printf("Поток %d работает\n", id);
    return NULL;
}

int ids[] = {1, 2, 3};
pthread_t threads[3];

for (int i = 0; i < 3; i++) {
    pthread_create(&threads[i], NULL, worker, &ids[i]);
}

for (int i = 0; i < 3; i++) {
    pthread_join(threads[i], NULL);
}

10.7. Дополнительные механизмы потоков

pthread_t tid;
pthread_create(&tid, NULL, worker, NULL);
pthread_detach(tid);

#include <pthread.h>

pthread_key_t key;

void init() {
    pthread_key_create(&key, NULL);
}

void *get_thread_data() {
    return pthread_getspecific(key);
}

void set_thread_data(void *data) {
    pthread_setspecific(key, data);
}

Отмена потока:

pthread_cancel(tid);

pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);

void cleanup_handler(void *arg) {
    free(arg);
}
pthread_cleanup_push(cleanup_handler, buffer);

pthread_cleanup_pop(1);

Резюме

Ключевые моменты лекции:

1. UNIX-стандарты (POSIX, SUS) обеспечивают переносимость системного ПО
2. ELF — основной формат исполняемых файлов в UNIX/Linux
3. Файловая модель UNIX — «всё есть файл» с 7 типами файлов
4. Права доступа — модель rwx + ACL для гибкого управления
5. Файловая система — inodes, суперблоки, журналирование
6. Процессы — fork/exec/wait, copy-on-write, зомби и сироты
7. Сигналы — асинхронное уведомление с sigaction для надёжной обработки
8. IPC — pipes, FIFO, очереди сообщений, семафоры, разделяемая память
9. System V IPC vs POSIX IPC — два стандарта с разным API
10. pthreads — стандартный API потоков POSIX с rich функциональностью

Вопросы для самопроверки

1. Чем отличается системный вызов от библиотечной функции? Приведите примеры.
2. Какие основные секции содержит ELF-файл и для чего они предназначены?
3. Объясните разницу между hard link и symbolic link на уровне inodes.
4. Что произойдёт при setuid-программе и зачем это нужно?
5. Чем отличаются зомби и сироты? Как избавиться от зомби?
6. Почему sigaction() предпочтительнее signal()?
7. В чём разница между pipe() и mkfifo()?
8. Сравните System V IPC и POSIX IPC — преимущества каждого подхода.
9. Что такое copy-on-write и почему fork() быстрый благодаря этому механизму?
10. Как работает thread-specific data и в каких ситуациях оно необходимо?

Практические задания

Самостоятельная работа (8 часов):

1. Написать программу, использующую stat() и макросы S_IS* для классификации файлов в указанном каталоге
2. Реализовать программу с fork()+exec()+wait() для создания конвейера из трёх процессов (аналог cmd1 | cmd2 | cmd3)
3. Написать клиент-серверное приложение с использованием именованных каналов (FIFO) или очередей сообщений POSIX
4. Создать многопоточное приложение с использованием pthread и разделяемой памяти POSIX для обмена данными между потоками

Рекомендуемая литература